『Effective Haskell』

https://gyazo.com/7cb2ad786ba4982fc3c89a955134df04

2023/2/14

練習問題があるらしい

ただ、最後の方ではMonad transformerとかType Familyも扱っている

Introduction

Why Choose Haskell?

Why This Book

How to Read This Book

Getting Started with Haskell

Exploring Haskell Interactively

Writing Your First Haskell Program

Formatting Haskell Code

Creating New Variables

Writing Functions

Creating Local Variables Using Let Bindings

Running Code Conditionally Using Branches

Writing Recursive Functions

Summarizing

Exercises

Working With Lists

Writing Code Using Lists

Destructuring Values With Pattern Matching

Understanding How Programs Are Evaluated

Summarizing

Exercises

Getting Started With Types

Working With Basic Haskell Types

Annotating Values with Type Information

Looking Up Type Information

Writing Type Annotations for Functions

Reading Type Errors

Working with Polymorphic Functions

Exploring The Type Space of an Application with Undefined

Looking at the Type of main

Summarizing

Exercises

Creating New Types

Creating Data Types and Records

Creating Sum Types

Creating Inductively Defined Data Structures

Building A Calculator

Functions as Data Types

Creating Types Aliases

Summary

Exercises

Creating And Structuring Haskell Projects

Creating Haskell Projects

Depending On Other Files

Creating Your Own Modules

Writing Documentation and Packaging

Exercises

Type Classes

Using Ad-Hoc Polymorphism with Typeclasses

Specifying Typeclass Instances with Type Applications

Wrapping Types with Newtype

Understanding Higher Kinded Types and Polymorphism

Deriving Instances

Deriving More Things

Exercises

Understanding IO

Talking About IO

Performing IO in a Pure, Lazy Language

Ordering and Combining IO Actions

Independently Sequencing IO Actions

Mapping IO Values With fmap

Running IO In Real Applications

Summarizing

Exercises

Working with the Local System

Building Applications with IO

Creating A Pager

Viewing the contents of an ASCII or UTF8 encoded text file

Viewing Text One Page at a Time

Adding A Status Line with Metadata

Showing the Status Bar and Refactoring runHCat

Summarizing

Exercises

Introducing Monads

Mapping Functors

Applying Applicatives

Working With The Monad Typeclass

Understanding The Laws of The Land

Using The Functor Laws

Using The Monads Laws

Using The Applicative Laws

Mutable Data In The Real World excerpt

Using Mutable References In A Pure Language

Working With IORefs

Building A Basic Metrics System with IORefs

Dealing With Lazy IO

Summarizing

Exercises

Serializing Heterogenous Data

Heterogenous Data in Haskell

A First Pass At A File Archiver

Serializing With TypeClasses

Building A List Of FilesDatas

Summary

Exercises

Deserializing Heterogenous Data

Extracting Heterogenous Values from the Archive

Deserialization as Parsing

Creating A Parsing Function

Building A Monadic Parser

Parsing A List Of Values

Adding A Monad Instance

Adding a MonadFail Instance

Summarizing

Exercises

Monad Transformers

Composing Monads

Carrying Around an Environment With The Reader Monad

Generating Exceptions and Handling Failure

Transforming With IO Actions

Dealing With Mutable State

Handling Data Efficiently

Using Mutable Values in Pure Functions with ST

Working With Mutable Arrays

Fast Mutable Vectors

Concurrency and Mutability with STM

Summarizing

Exercises

Type Families

Creating Typeclasses With More Than One Parameter

Using Functional Dependencies

Creating Constraints On TypeClass Parameters

Adding Associated Type Families To Typeclasses

Writing Type-Level Functions with Closed Type Families

Extending Type-Level Programs with Open Type Families

Programming With Types

Programming with Types

Building A Combinator With GADTs